Job scheduling game

In game theory, a job scheduling game is a game that models a scenario in which multiple selfish users wish to utilize multiple processing machines. Each user has a single job, and he needs to choose a single machine to process it. The incentive of each user is to have his job run as fast as possible.

Definition

Job scheduling games are the following set of problems: given $M$ machines and $N$ jobs. Each job $i$ is associated with a vector $p_{i}=(p_{i}^{1},...,p_{i}^{m})$ , corresponding to its size on each machine (i.e., $p_{i}^{j}$ is the processing time of job $i$ on machine $j$ ). Players correspond to jobs. The strategy set of each player is the set of machines. Given a strategy for each player, the total load on each machine is the sum of processing times of the jobs that chose that machine. Usually each player seeks to minimize the total load on its chosen machine. The standard objective function is minimizing the total load on the most-loaded machine (this objective is called makespan minimization).

For example: given game with 2 machines M1 and M2 and 2 jobs J1 and J2. The rows represent the strategies job J1 can choose and the columns represent the strategies job J2 can choose.


J1/J2	M1	M2
M1	(1,10)	(10,10)
M2	(1,1)	(10,1)

Motivation

The problem of dividing several jobs among several machines in a way that optimizes some global objective function is well known and has been widely studied in computer science. In this type of problems there is a central designer that determines the allocation of jobs into machines and all the participating entities are assumed to obey the protocol. However, since the emergence of the Internet, problems in distributed settings has been studied as well. In this type of problems, different machines and jobs may be owned by different strategic entities, who will typically attempt to optimize their own objective rather than the global objective.

Main Properties

The price of stability is used to measure inefficiency. It differentiates between games in which all equilibria are inefficient and those in which there exists an equilibrium that is inefficient

For every job scheduling game price of stability is equal to 1

proof: Price of stability is equal to best Nash equilibrium divided by OPTimum. Therefore, in order to prove that Price of stability = 1 it is sufficient to prove that the optimum is equal to the best Nash equilibrium. In order to prove that, it is sufficient to prove that there is an OPTimum solution which is in Nash equilibrium, since if the OPTimum is also Nash equilibrium it is especially best Nash equilibrium.

The optimum state is when the most loaded machine is the less loaded it can be. Assuming each job which was scheduled to the most loaded machine will not aspire to move to another machine. In addition, each job that was scheduled to a machine which is not the most loaded one, will not aspire to move to the most loaded machine. Given a game with in the optimum state with $M$ machines. Assuming there is a job $x$ that aspire to be scheduled on machine $M_{i}$ instead of being scheduled on the most loaded machine - $M_{d}$ . In that case, there exist a machine that after job $x$ was transfer, its load is less than the load of the machine $M_{d}$ before job $x$ changed. This is in contradiction to the assumption that the game is in the OPTimum state. Therefore, job will not be reassigned from and to the most loaded machine. The scheduling of the $M-1$ machines left and the number of jobs left (without the jobs that were scheduled on machine $M_{d}$ ) follows: For the same reasons that were mention earlier, there is no job that would like to move from the (new) most load machine or to the (new) most load machine. By passing all $M$ machines in inductive steps there will be n jobs scheduled to $M$ . These jobs will not aspire to move from their own machine. Meaning, for each job, its strategy is its best response to the profile. In other words, there is an OPTimum state which is also in Nash equilibrium. Thus, price of stability = 1.

The price of anarchy is a concept from game theory that describes the difference in maximum social utility and the utility of an equilibrium point of the game.

There exist job scheduling game where Price of anarchy is not bounded

claim: Price of anarchy = $\infty$ .

proof: Given a game with 2 machines $M_{1}$ and $M_{2}$ and 2 jobs $J_{1}=1,K$ and $J_{2}=K,1$ for any natural $K>1$ . In this game, job $J_{1}$ cost 1 on machine $M_{1}$ and $K$ on machine $M_{2}$ , and job $J_{2}$ cost $K$ on machine $M_{1}$ and 1 on machine $M_{2}$ . Therefore, the OPTimum state is when $J_{1}$ is scheduled to $M_{1}$ and $J_{2}$ scheduled to $M_{2}$ since the objective function is 1. Moreover, the worst Nash equilibrium is when $J_{1}$ is scheduled to $M_{2}$ and $J_{2}$ scheduled to $M_{1}$ since the objective function is $K$ . It is a Nash equilibrium because if job $J_{1}$ will be scheduled to machine $M_{2}$ the total load of this machine will raise from $K$ to $K+1$ , and likewise for job $J_{2}$ . Since Price of anarchy is equal to worst Nash equilibrium divided by Optimum, price of anarchy = $K$ . This is true for any natural $K$ and thus price of anarchy is not bounded as claimed.

External links